class Any
    {
        // 基类
        class placeholder // 包含纯虚函数，是抽象类，不能直接实例化对象
        {
        public:
            virtual ~placeholder() {
                /*placeholder 类是一个纯虚类，
                它的析构函数需要提供一个实现，否则会导致链接错误。
                纯虚析构函数的实现通常是一个空函数体。*/
            }
            virtual const std::type_info &type() = 0; // 返回参数的类型
            virtual placeholder *clone() = 0;   // 克隆出一个相同的对象，实现深拷贝
        };

        template <typename T>
        class subholder : public placeholder // 子类
        {
        public:
            subholder(const T &operand) : _val(operand) {}
            ~subholder() {}                       // 析构
            const std::type_info &type() override // 返回对象的数据类型
            {
                return typeid(T);
            }
            placeholder *clone() override
            {
                return new subholder(_val);
            }

        public:
            T _val; // 数据对象
        };

    private:
        placeholder *_content; // 定义基类指针
    public:
        Any() {};

        template <typename T>
        Any(const T &operand);

        bool has_value(); // 是否已经有值

        Any(const Any &operand); //拷贝构造

        template <typename T>
        Any &operator=(const T &operand); // 赋值运算符重载

        Any &operator=(Any operand); // 赋值运算符重载

        void swap(Any &operand); // 交换数据

        const std::type_info &type(); // 返回保存的对象的数据类型

        template <typename T>
        T *get_val(); // 获取指向数据对象的指针
    };